//package com.pkx.guide.task;
//
//import com.alibaba.fastjson.JSONArray;
//import com.alibaba.fastjson.JSONObject;
//import com.fasterxml.jackson.databind.ObjectMapper;
//import com.pkx.guide.common.util.DateUtils;
//import com.pkx.guide.common.util.StringUtils;
//import com.pkx.guide.fcms.service.FcmsPlayService;
//import com.pkx.guide.holidays.entity.THolidaysDate;
//import com.pkx.guide.holidays.key.THolidaysDateKey;
//import com.pkx.guide.info.entity.ProducerQest;
//import com.pkx.guide.info.entity.TInfoGuide;
//import com.pkx.guide.info.entity.TInfoGuidePublish;
//import com.pkx.guide.info.entity.TInfoNetworkConfig;
//import com.pkx.guide.info.service.TInfoGuidePublishService;
//import com.pkx.guide.info.service.TInfoGuideService;
//import com.pkx.guide.info.service.TInfoGuideStatusService;
//import com.pkx.guide.info.service.TInfoNetworkConfigService;
//import com.pkx.guide.qianfeng.service.QianFengPlayLedService;
//import com.sansi.tools.RetrunData;
//import jakarta.annotation.Resource;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.data.redis.core.RedisTemplate;
//import org.springframework.scheduling.annotation.Scheduled;
//import org.springframework.stereotype.Component;
//
//import java.time.DayOfWeek;
//import java.time.LocalDate;
//import java.time.LocalDateTime;
//import java.time.LocalTime;
//import java.time.format.DateTimeFormatter;
//import java.time.temporal.ChronoUnit;
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.List;
//import java.util.concurrent.ArrayBlockingQueue;
//import java.util.concurrent.BlockingQueue;
//
///**
// * 乾丰 自动触发任务
// *
// * @Author : YangLe
// * @create 2025/8/28 17:19
// */
//@Slf4j
//@Component
//public class QianFengAutomatic {
//
//
//    @Resource
//    private TInfoGuideStatusService tInfoGuideStatusService;
//    // 依赖注入（假设已通过Spring注入）
//    // 修改为构造函数注入
//    @Resource
//    private  TInfoGuidePublishService tInfoGuidePublishService;
//
////    public QianFengAutomatic(TInfoGuidePublishService tInfoGuidePublishService) {
////        this.tInfoGuidePublishService = tInfoGuidePublishService;
////    }
//
//    @Resource
//    private TInfoNetworkConfigService infoNetworkConfigService;
//    @Resource
//    private TInfoGuideService guideService;
//
//    @Resource
//    private FcmsPlayService fcmsPlayService;
//
//    @Resource
//    private RedisTemplate<String, Object> redisTemplate;
//    /**
//     * 每10秒执行一次：仅在节假日、调休日、周六周日检查设备状态，离线则发布
//     */
//    // 1. 类级别定义统一的格式器（关键：避免局部重定义导致混乱）
//    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
//    private static final DateTimeFormatter DATE_TIME_FORMATTER_FULL = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//    private static final DateTimeFormatter DATE_TIME_FORMATTER_DATE_ONLY = DateTimeFormatter.ISO_LOCAL_DATE;
//
//
//
//    @Resource
//    private QianFengPlayLedService qianFengPlayLedService;
//
////        @Scheduled(
////            cron = "0 10,20,30,40,50,00 * * * ?"
////    )
////    @Scheduled(
////            cron = "0 * * * * ?"
////    )
//
//    /**
//     * 定时发布 每5分钟运行一次
//     */
//    @Scheduled(cron = "0 0,5,10,15,20,25,30,35,40,45,50,55 * * * ?")
//    public  void autoPublishByDate() {
//    // 添加空值检查
//    if (tInfoGuidePublishService == null) {
//        log.error("TInfoGuidePublishService 未正确注入");
//        return;
//    }
//
//    try {
//                // 执行核心发布逻辑
//                executePublishLogic();
//                log.info("自动发布执行成功");
//            } catch (Exception e) {
//                log.error("自动发布执行异常", e);
//        }
//    }
//
//    /**
//     * 提取核心发布逻辑为单独方法，使代码结构更清晰
//     */
//    private void executePublishLogic() throws Exception {
//        try {
//
//            log.info("开始乾丰自动发布检查（节假日/调休/周末专用）");
//            LocalDate today = LocalDate.now();
//            // 当前时间 时分秒
//            log.info("当前时间：{}", LocalDateTime.now());
//            String todayDateStr = today.format(DATE_FORMATTER);
//            LocalDateTime currentTime = LocalDateTime.now();
//            log.info("当前日期：{}", todayDateStr);
//
//            //            // 从数据库查询所有任务配置
//            TInfoGuidePublish tInfoGuidePublish2 = new TInfoGuidePublish();
//            tInfoGuidePublish2.setDelFlg(0);
//            tInfoGuidePublish2.setState(0);
//            tInfoGuidePublish2.setModeType(0);
//
//            List<TInfoGuidePublish> basePublishList2 = tInfoGuidePublishService.listByEntity(tInfoGuidePublish2);
//
//            LocalDateTime now = LocalDateTime.now();
//            boolean shouldExecute = false;
//            LocalDate today1 = now.toLocalDate();
//            ArrayList<TInfoGuidePublish> tInfoGuidePublishes = new ArrayList<>();
//            for (TInfoGuidePublish task : basePublishList2) {
//                String timeStr = task.getStartTimeScale();
//                if (timeStr == null || timeStr.trim().isEmpty()) {
//                    continue; // 跳过空时间任务
//                }
//
//                try {
//                    LocalTime taskTimeHM = LocalTime.parse(timeStr, DateTimeFormatter.ofPattern("HH:mm"));
//                    log.error("任务时间：{}", taskTimeHM);
//                    LocalDate taskDate = today1;
//                    LocalDateTime taskTime = LocalDateTime.of(taskDate, taskTimeHM);
//
//                    // 截断当前时间到分钟级，确保精度匹配
//                    LocalDateTime nowTruncated = now.truncatedTo(ChronoUnit.MINUTES);
//                    if (taskTime.isEqual(nowTruncated)) {
//                        shouldExecute = true;
//                        tInfoGuidePublishes.add(task); // 添加所有符合条件的任务
//                        log.info("找到当前分钟内的任务，任务时间: {}", taskTime.format(DATE_TIME_FORMATTER_FULL));
//                        // 不要用break，继续检查后续任务
//                    }
//                } catch (Exception e) {
//                    log.error("解析任务时间出错，任务ID: {}", task.getId(), e);
//                }
//            }
//
//           // 遍历完所有任务后，再判断是否有符合条件的任务
//            if (!shouldExecute) {
//                log.info("没有需要执行的自动发布任务");
//                return; // 此时才结束方法
//            }
//
//            log.error("需要执行的任务列表：{}", tInfoGuidePublishes);
//           log.error("需要执行的任务数量：{}", tInfoGuidePublishes.size());
//
//
//
//            ArrayList<String> strings = new ArrayList<>();
//            // 判断今天周六日
//            List<THolidaysDate> holidaysList = getHolidaysListFromRedis();
//
//            log.info("节假日数据：{}", holidaysList);
//            // 修复空指针判断逻辑（先判断null再判断空）
//            if (holidaysList != null && !holidaysList.isEmpty()) {
//                for (THolidaysDate tHolidaysDate : holidaysList) {
//                    String startTime = tHolidaysDate.getStartTime();
//                    String endTime = tHolidaysDate.getEndTime();
//                    // 判断今天是不是在startTime和endTime之间
//                    if (todayDateStr.compareTo(startTime) >= 0 && todayDateStr.compareTo(endTime) <= 0) {
//                        strings.add(todayDateStr);
//                    }
//
//                    // 判断今天是不是调休
//                    String adjustedTime = tHolidaysDate.getAdjustedTime();
//                    // 修复空字符串判断逻辑
//                    if (adjustedTime != null && !adjustedTime.isEmpty()) {
//                        // 处理逗号分隔的多个调休日期
//                        String[] adjustedDateTimeStrs = adjustedTime.split(",");
//                        for (String dateTimeStr : adjustedDateTimeStrs) {
//                            String adjustedDate = extractDateFromDateTimeStr(dateTimeStr);
//                            // 避免重复添加
//                            if (!strings.contains(adjustedDate)) {
//                                strings.add(adjustedDate);
//                            }
//                        }
//                    }
//                }
//
//                for (String string : strings) {
//                    if (string.equals(todayDateStr)) {
//                        // 查询符合条件的任务
//                        TInfoGuidePublish tInfoGuidePublish = new TInfoGuidePublish();
//                        tInfoGuidePublish.setDelFlg(0);
//                        tInfoGuidePublish.setState(0);
//                        tInfoGuidePublish.setModeType(0);
//                        tInfoGuidePublish.setHolidays(0);
//                        List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.listByEntity(tInfoGuidePublish);
//
//                        log.info("符合节假日的总数: {}", basePublishList.size());
//
//                        // 筛选任务
//                        List<TInfoGuidePublish> filteredList = filterTasksByTime(basePublishList, todayDateStr, currentTime);
//                        log.info("符合节假日经过时间筛选后的任务数量：{}", filteredList.size());
//                        extracted(filteredList);
//                    }
//                }
//            }
//
//
//            if (today.getDayOfWeek() == DayOfWeek.SATURDAY || today.getDayOfWeek() == DayOfWeek.SUNDAY) {
//                if (!strings.contains(todayDateStr)) {
//                    strings.add(todayDateStr);
//                    log.info("今天是周六周末：{}", todayDateStr);
//                }
//            }
//            log.info("今天是周六日，符合周末的日期：{}", strings);
//            log.info("今天是周六日：{}", todayDateStr);
//
//            // 处理非节假日情况
//            if (strings.isEmpty()) {
//
//                TInfoGuidePublish tInfoGuidePublish = new TInfoGuidePublish();
//                tInfoGuidePublish.setDelFlg(0);
//                tInfoGuidePublish.setState(0);
//                tInfoGuidePublish.setModeType(0);
//                tInfoGuidePublish.setHolidays(1);
//                List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.listByEntity(tInfoGuidePublish);
//
//
//                log.info("不符合节假日的总数: {}", basePublishList.size());
//
//                List<TInfoGuidePublish> filteredList = filterTasksByTime(basePublishList, todayDateStr, currentTime);
//                log.info("不符合节假日,经过时间筛选后的任务数量：{}", filteredList.size());
//                extracted(filteredList);
//            } else {
//                for (String string : strings) {
//                    log.info("今天是周六日，符合周末的日期：{}", string);
//                    if (string.equals(todayDateStr)) {
//                        log.error("周六日");
//                        TInfoGuidePublish tInfoGuidePublish = new TInfoGuidePublish();
//                        tInfoGuidePublish.setDelFlg(0);
//                        tInfoGuidePublish.setState(0);
//                        tInfoGuidePublish.setModeType(0);
//                        tInfoGuidePublish.setHolidays(1);
//                        List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.listByEntity(tInfoGuidePublish);
//                        if (basePublishList.isEmpty()){
//                            log.error("没有需要发布的任务");
//                        }
//                        log.info("符合周六日的总数: {}", basePublishList.size());
//                        List<TInfoGuidePublish> filteredList = filterTasksByTime(basePublishList, todayDateStr, currentTime);
//                        log.info("符合周六日经过时间筛选后的任务数量：{}", filteredList.size());
//                        extracted(filteredList);
//                    }
//                }
//            }
//        } catch (Exception e) {
//            log.error("自动发布异常", e);
//        }
//    }
//
//
//    private void extracted(List<TInfoGuidePublish> filteredList) throws Exception {
//        log.info("开始处理任务");
//        ObjectMapper objectMapper = new ObjectMapper();
//
//        for (TInfoGuidePublish task : filteredList) {
//            // 5.2 解析发布详情（IP列表）
////            String publishDetail = task.getPublishDetail();
////            if (StringUtils.isEmpty(publishDetail)) {
////                log.warn("任务[{}]：发布详情为空，跳过处理", task.getId());
////                continue;
////            }
//            // 三四发布
//            if (task.getGuideType()==0){
//                // 5.3 检查设备状态并发布
//                checkSansiDeviceAndPublish(task);
//                log.info("三四发布任务[{}]：发布成功", task.getId());
//            }
//            // 乾丰发布
//            if (task.getGuideType()==1){
//                checkQianFengDeviceAndPublish(task);
//                log.info("乾丰发布任务[{}]：发布成功", task.getId());
//            }
//
//
//        }
//    }
////    @Resource
////    private DynamicTaskManager dynamicTaskManager;
//    public void checkSansiDeviceAndPublish(TInfoGuidePublish tInfoGuidePublish) {
//        if (tInfoGuidePublish == null){
//            throw new IllegalArgumentException("参数为空");
//        }
//        tInfoGuidePublish.setPublishTime(DateUtils.getCurrentTimeStr());
//        // 查询情报板信息
//        TInfoGuide guide = guideService.selectById(tInfoGuidePublish.getGuideId());
//        if (guide == null){
//            throw new RuntimeException("未查询到情报板信息");
//        }
//
//        RetrunData result = fcmsPlayService.fcmsActivePlayList(guide, tInfoGuidePublish.getPlayListName());
//        log.info("手动发布结果：{}", JSONObject.toJSONString(result));
//    }
//
//
//    /**
//     * 子方法：筛选“任务时间晚于当前时间”的任务
//     */
//    private List<TInfoGuidePublish> filterTasksByTime(List<TInfoGuidePublish> baseList, String todayDateStr, LocalDateTime currentTime) {
//        List<TInfoGuidePublish> result = new ArrayList<>();
//
//        log.error("filterTasksByTime数量"+baseList.size());
//        for (TInfoGuidePublish task : baseList) {
//            log.error("task:{}",task);
//            String startTimeScale = task.getStartTimeScale();
//            String endTimeScale = task.getEndTimeScale();
//            if (StringUtils.isEmpty(startTimeScale)) {
//                log.warn("任务[{}]：startTimeScale为空，跳过筛选", task.getId());
//                continue;
//            }
//            if (StringUtils.isEmpty(endTimeScale)) {
//                log.warn("任务[{}]：endTimeScale为空，跳过筛选", task.getId());
//                continue;
//            }
//
//            try {
//                // 补全时间为 yyyy-MM-dd HH:mm:ss 格式
//                String completeTime = 补全时间(startTimeScale);
////                String completeEndTime = 补全时间(endTimeScale);
//                String fullTimeStr = todayDateStr + " " + completeTime;
////                String fullTimeEnd = todayDateStr + " " + completeEndTime;
//                // 用完整格式器解析（此时fullTimeStr已确保是 HH:mm:ss 格式）
//                LocalDateTime taskTime = LocalDateTime.parse(fullTimeStr, DATE_TIME_FORMATTER_FULL)
//                       ;
////                LocalDateTime endTime = LocalDateTime.parse(fullTimeEnd, DATE_TIME_FORMATTER_FULL);
//
//                // 截断时间到分钟级（避免秒/纳秒差异导致匹配失败）
//                LocalDateTime taskTimeTruncated = taskTime.truncatedTo(ChronoUnit.MINUTES);
//                LocalDateTime currentTimeTruncated = currentTime.truncatedTo(ChronoUnit.MINUTES);
//
//          // 仅当任务开始时间（分钟级）等于当前时间（分钟级）时才符合条件
//                if (taskTimeTruncated.isEqual(currentTimeTruncated)) {
//                    result.add(task);
//                    log.debug("任务[{}]：符合时间条件（当前时间：{} == 开始时间：{}）",
//                            task.getId(),
//                            currentTimeTruncated.format(DATE_TIME_FORMATTER_FULL),
//                            taskTimeTruncated.format(DATE_TIME_FORMATTER_FULL));
//                }
//            } catch (Exception e) {
//                // 这里可以添加异常处理逻辑
//                log.error("处理任务[{}]时间时发生错误", task.getId(), e);
//            }
//        }
//        return result;
//    }
//
//    /**
//     * 子方法：补全时间为 HH:mm:ss 格式（兼容 HH、HH:mm、HH:mm:ss，新增非法片段校验）
//     *
//     * @param startTimeScale 原始时间字符串（如 "12"、"12:30"、"12:30:45"）
//     * @return 标准 HH:mm:ss 格式时间
//     * @throws IllegalArgumentException 非法时间格式时抛出
//     */
//    private String 补全时间(String startTimeScale) {
//        // 1. 分割时间片段，同时过滤空字符串（处理 "12::07" 这类多冒号的情况）
//        String[] timeParts = Arrays.stream(startTimeScale.split(":"))
//                .filter(StringUtils::isNotEmpty)
//                .toArray(String[]::new);
//
//        // 2. 校验分割后的片段数量（只能是 1、2、3 个）
//        if (timeParts.length < 1 || timeParts.length > 3) {
//            throw new IllegalArgumentException("时间片段数量非法（需1-3个）：" + startTimeScale);
//        }
//
//        // 3. 校验每个片段是否为合法数字，且符合时间范围（HH:0-23, mm/ss:0-59）
//        int hour = parseAndValidateTimePart(timeParts[0], 0, 23, "小时", startTimeScale);
//        int minute = 0;
//        int second = 0;
//
//        // 处理分钟（片段数量>=2时）
//        if (timeParts.length >= 2) {
//            minute = parseAndValidateTimePart(timeParts[1], 0, 59, "分钟", startTimeScale);
//        }
//
//        // 处理秒（片段数量=3时）
//        if (timeParts.length == 3) {
//            second = parseAndValidateTimePart(timeParts[2], 0, 59, "秒", startTimeScale);
//        }
//
//        // 4. 格式化为标准 HH:mm:ss（补前导零，确保2位）
//        return String.format("%02d:%02d:%02d", hour, minute, second);
//    }
//
//    /**
//     * 辅助方法：解析时间片段并校验范围（避免重复代码）
//     *
//     * @param part     时间片段（如 "12"、"30"）
//     * @param min      最小值（如小时0，分钟0）
//     * @param max      最大值（如小时23，分钟59）
//     * @param partName 片段名称（用于错误提示，如 "小时"、"分钟"）
//     * @param original 原始时间字符串（用于错误提示）
//     * @return 解析后的整数
//     * @throws IllegalArgumentException 非法数字或超出范围时抛出
//     */
//    private int parseAndValidateTimePart(String part, int min, int max, String partName, String original) {
//        int value;
//        try {
//            // 解析为整数（处理 "08" 这类带前导零的情况，Integer.parseInt 会自动转为8，不影响）
//            value = Integer.parseInt(part);
//        } catch (NumberFormatException e) {
//            throw new IllegalArgumentException(
//                    String.format("时间%s包含非法数字（%s）：%s", partName, part, original), e);
//        }
//
//        // 校验范围
//        if (value < min || value > max) {
//            throw new IllegalArgumentException(
//                    String.format("时间%s超出范围（需%d-%d）：%s", partName, min, max, original));
//        }
//        return value;
//    }
//
//    private final BlockingQueue<ProducerQest> dataQueue = new ArrayBlockingQueue<>(10);
//
//    /**
//     * 子方法：检查设备状态并执行发布
//     */
//    private void checkQianFengDeviceAndPublish(TInfoGuidePublish task) throws Exception {
////        log.info("开始发布，任务ID：{}", task.getId());
////
////        // 1. 基础参数校验（确保发布详情不为空，避免后续空指针）
////        if (task == null || StringUtils.isEmpty(task.getPublishDetail())) {
////            log.error("任务[{}]：发布详情为空，终止发布", task.getId());
////            throw new IllegalArgumentException("任务发布详情不能为空");
////        }
////
////        // 2. 查询乾丰上位机网络配置（保留原有逻辑）
////        TInfoNetworkConfig networkConfig = infoNetworkConfigService.selectByGuideType(1);
////        if (networkConfig == null) {
////            log.error("任务[{}]：未查询到网络配置信息，终止发布", task.getId());
////            throw new RuntimeException("未查询到网络配置信息");
////        }
////        String deviceIp = networkConfig.getIp();
////        Integer devicePort = networkConfig.getPort();
////        log.info("任务[{}]：获取到设备IP：{}，端口：{}", task.getId(), deviceIp, devicePort);
////
////        // 3. 解析发布详情中的IP列表（对应你提供的data数组）
////        JSONArray originalIpArray = JSONArray.parseArray(task.getPublishDetail());
////        int totalIpCount = originalIpArray.size();
////        int batchSize = 1; // 每批发送5个IP
////        int totalBatches = (totalIpCount + batchSize - 1) / batchSize; // 向上取整算总批次
////        log.info("任务[{}]：待发送IP总数：{}，每批{}个，共需发送{}批",
////                task.getId(), totalIpCount, batchSize, totalBatches);
////
////        // 4. 循环分批发送IP
////        for (int i = 0; i < totalBatches; i++) {
////            // 4.1 计算当前批次的IP索引范围（避免越界）
////            int startIdx = i * batchSize;
////            int endIdx = Math.min((i + 1) * batchSize, totalIpCount);
////            // 4.2 截取当前批次的IP子数组
////            JSONArray batchIpArray = new JSONArray();
////            for (int j = startIdx; j < endIdx; j++) {
////                batchIpArray.add(originalIpArray.get(j));
////            }
////            log.info("任务[{}]：处理第{}/{}批，IP范围：索引{}~{}，当前批IP数量：{}",
////                    task.getId(), i + 1, totalBatches, startIdx, endIdx - 1, batchIpArray.size());
////
////            // 4.3 构建当前批次的请求参数（匹配你提供的参数格式：user、pwd、cmd、data）
////            JSONObject batchParam = new JSONObject();
////            batchParam.put("user", networkConfig.getUsername()); // 沿用配置中的用户名
////            batchParam.put("pwd", networkConfig.getPassword()); // 沿用配置中的密码
////            batchParam.put("cmd", "2"); // 注意：你的参数中cmd为"2"，需与原有逻辑确认是否需要动态调整
////            batchParam.put("data", batchIpArray); // 传入当前批次的IP子数组
////
////            // 4.4 发送当前批次并获取结果
////            String batchResult = qianFengPlayLedService.controlLed(deviceIp, devicePort, batchParam.toJSONString());
////            log.info("任务[{}]：第{}/{}批发送结果：{}", task.getId(), i + 1, totalBatches, batchResult);
////
////            // 4.5 解析结果并处理（保留原有校验逻辑，适配分批场景）
////            JSONObject resultJson = JSONObject.parseObject(batchResult);
////            if (resultJson == null) {
////                log.warn("任务[{}]：第{}/{}批 - 设备IP[{}]状态异常（返回结果为空），跳过该批状态更新",
////                        task.getId(), i + 1, totalBatches, deviceIp);
////                continue;
////            }
////
////            String code = resultJson.getString("code");
////            if (!"0".equals(code)) {
////                log.warn("任务[{}]：第{}/{}批 - 设备IP[{}]状态异常（code={}），跳过该批状态更新",
////                        task.getId(), i + 1, totalBatches, deviceIp, code);
////                continue;
////            }
////
////            // 4.6 批次发送成功后，更新该批IP对应的情报板状态
////            tInfoGuideStatusService.updateGuideStatus(batchIpArray.toJSONString());
////            log.info("任务[{}]：第{}/{}批 - IP情报板状态更新完成", task.getId(), i + 1, totalBatches);
////
////            // 4.7 可选：添加批次间隔，避免设备短时间内处理压力过大
////            try {
////                Thread.sleep(300); // 300毫秒间隔，可根据设备性能调整
////            } catch (InterruptedException e) {
////                Thread.currentThread().interrupt();
////                log.warn("任务[{}]：第{}/{}批 - 批次间隔线程被中断", task.getId(), i + 1, totalBatches, e);
////            }
////        }
////
////        log.info("任务[{}]：所有{}批IP数据发布处理完成", task.getId(), totalBatches);
//        if (task == null || StringUtils.isEmpty(task.getPublishDetail())) {
//            throw new IllegalArgumentException("参数为空");
//        }
//        // 查询乾丰上位机网络配置
//        TInfoNetworkConfig networkConfig = infoNetworkConfigService.selectByGuideType(1);
//        if (networkConfig == null) {
//            throw new RuntimeException("未查询到网络配置信息");
//        }
//        log.error("自动发布：{}"+networkConfig);
//        JSONObject param = new JSONObject();
//        param.put("user", networkConfig.getUsername());
//        param.put("pwd", networkConfig.getPassword());
//        param.put("cmd", "1");
//        // 先解析原始长数组，后续分批使用
//        JSONArray originalPublishDetail = JSONArray.parseArray(task.getPublishDetail());
//        param.put("data", originalPublishDetail); // 原param保留，不影响其他逻辑
//
////        ProducerQest producerQest = new ProducerQest();
////        producerQest.setTask(task);
////        producerQest.setParam(param);
////        producerQest.setNetworkConfig(networkConfig);
////        producerQest.setIpList(originalPublishDetail.toJSONString());
////        producerQest.setIpListSize((int) originalPublishDetail.size());
////        dataQueue.put(producerQest);
//
//        // 4. 发送当前批次并校验结果
//        String batchResult = qianFengPlayLedService.controlLed(
//                            networkConfig.getIp(),
//                            networkConfig.getPort(),
//                param.toJSONString()
//        );
//        log.error("自动发布结果：{}"+batchResult);
//        // 6. 批次成功后，更新该批次的情报板状态
//        tInfoGuideStatusService.updateGuideStatus(originalPublishDetail.toJSONString());
//
//
//                }
//
//
//         //添加自动发布
////        TRecordGuidePublish tGuiGuidePublishRecord = new TRecordGuidePublish();
////        BeanUtils.copyProperties(task, tGuiGuidePublishRecord);
////        tGuiGuidePublishRecord.setGuidePublishId(task.getGuideId());
////        tGuiGuidePublishRecord.setOperateType(0);
////        tGuiGuidePublishRecord.setId(null);
////        recordGuidePublishService.saveTRecordGuidePublish(tGuiGuidePublishRecord);
//
//
//    /**
//     * 判断今天是否是目标日期（节假日/调休/周末）
//     */
//    private boolean isHolidayOrAdjustedOrWeekend(LocalDate today, String todayDateStr, List<THolidaysDate> holidaysList) {
//        // 情况1：周六/周日
//        DayOfWeek dayOfWeek = today.getDayOfWeek();
//        boolean isWeekend = dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY;
//
//        // 情况2：节假日
//        boolean isHoliday = isTodayHoliday(todayDateStr, holidaysList);
//
//        // 情况3：调休日
//        boolean isAdjustedDay = isTodayAdjustedDay(todayDateStr, holidaysList);
//
//        return isWeekend || isHoliday || isAdjustedDay;
//    }
//
//
//    /**
//     * 判断今天是否是节假日（修复：根据字符串长度选择格式器）
//     */
//    private boolean isTodayHoliday(String todayDateStr, List<THolidaysDate> holidaysList) {
//        for (THolidaysDate holiday : holidaysList) {
//            String holidayDateTimeStr = holiday.getStartTime();
//            if (StringUtils.isEmpty(holidayDateTimeStr)) {
//                continue;
//            }
//            // 提取节假日日期（根据字符串长度选择格式器）
//            String holidayDate = extractDateFromDateTimeStr(holidayDateTimeStr);
//            if (todayDateStr.equals(holidayDate)) {
//                log.info("今天是节假日：{}", todayDateStr);
//                return true;
//            }
//        }
//        return false;
//    }
//
//    /**
//     * 判断今天是否是调休日（修复：根据字符串长度选择格式器）
//     */
//    private boolean isTodayAdjustedDay(String todayDateStr, List<THolidaysDate> holidaysList) {
//        for (THolidaysDate holiday : holidaysList) {
//            String adjustedTime = holiday.getAdjustedTime();
//            if (StringUtils.isEmpty(adjustedTime)) {
//                continue;
//            }
//            // 处理逗号分隔的多个调休日期
//            String[] adjustedDateTimeStrs = adjustedTime.split(",");
//            for (String dateTimeStr : adjustedDateTimeStrs) {
//                String adjustedDate = extractDateFromDateTimeStr(dateTimeStr);
//                if (todayDateStr.equals(adjustedDate)) {
//                    log.info("今天是调休日：{}", todayDateStr);
//                    return true;
//                }
//            }
//        }
//        return false;
//    }
//
//    /**
//     * 修复：根据字符串长度选择格式器（避免解析短格式报错）
//     * - 长度10：仅年月日（yyyy-MM-dd）→ 用 DATE_TIME_FORMATTER_DATE_ONLY
//     * - 长度19：完整时分秒（yyyy-MM-dd HH:mm:ss）→ 用 DATE_TIME_FORMATTER_FULL
//     */
//    private String extractDateFromDateTimeStr(String dateTimeStr) {
//        if (StringUtils.isEmpty(dateTimeStr)) {
//            log.warn("时间字符串为空，跳过解析");
//            return "";
//        }
//        try {
//            LocalDate date;
//            if (dateTimeStr.length() == 10) {
//                // 仅年月日（如 "2025-08-29"）
//                date = LocalDate.parse(dateTimeStr, DATE_TIME_FORMATTER_DATE_ONLY);
//            } else if (dateTimeStr.length() == 19) {
//                // 完整时分秒（如 "2025-08-29 00:00:00"）
//                LocalDateTime dateTime = LocalDateTime.parse(dateTimeStr, DATE_TIME_FORMATTER_FULL);
//                date = dateTime.toLocalDate();
//            } else {
//                log.warn("时间字符串长度异常（既非10也非19）：{}", dateTimeStr);
//                return "";
//            }
//            return date.format(DATE_FORMATTER);
//        } catch (Exception e) {
//            // 兜底：直接截取前10位（避免解析失败导致整个流程中断）
//            log.warn("时间字符串解析失败，尝试截取前10位：{}，错误：{}", dateTimeStr, e.getMessage());
//            return dateTimeStr.length() >= 10 ? dateTimeStr.substring(0, 10) : "";
//        }
//    }
//
//    /**
//     * 从Redis获取节假日列表（保持不变）
//     */
//    public List<THolidaysDate> getHolidaysListFromRedis() {
////        try {
//
////            LambdaQueryWrapper<THolidaysDate> tHolidaysDateLambdaQueryWrapper = new LambdaQueryWrapper<>();
////            tHolidaysDateLambdaQueryWrapper.eq(THolidaysDate::getDelFlg, 0);
////            List<THolidaysDate> list1 = tHolidaysDateService.list(tHolidaysDateLambdaQueryWrapper);
////
////        Object result = redisTemplate.opsForValue().get(THolidaysDateKey.KEY_HOLIDAYS_ALL);
//////            if (list1 instanceof List<?>) {
//////                List<?> list = (List<?>) list1;
//////                if (list.isEmpty() || list.get(0) instanceof THolidaysDate) {
//////                    return (List<THolidaysDate>) list;
//////                }
//////                log.warn("Redis中节假日数据元素类型不符，预期THolidaysDate");
//////            } else {
//////                log.warn("Redis中未找到有效节假日数据（非List类型）");
//////            }
//////        } catch (Exception e) {
//////            log.error("从Redis获取节假日数据失败", e);
//////        }
////        return List.of();
//            try {
//                // 从Redis获取数据
//                Object result = redisTemplate.opsForValue().get(THolidaysDateKey.KEY_HOLIDAYS_ALL);
//
//                // 判断Redis中的数据是否为空
//                if (result == null) {
//                    log.info("Redis中未找到节假日数据，key: KEY_HOLIDAYS_ALL");
//                    // 返回空列表或从数据库获取
//                    return new ArrayList<>();
//                }
//
//                // 检查数据类型并转换
//                if (result instanceof List<?>) {
//                    List<?> list = (List<?>) result;
//                    if (list.isEmpty()) {
//                        log.info("Redis中节假日数据为空列表");
//                        return new ArrayList<>();
//                    }
//                    // 类型安全检查
//                    if (list.get(0) instanceof THolidaysDate) {
//                        return (List<THolidaysDate>) list;
//                    } else {
//                        log.warn("Redis中节假日数据元素类型不符，预期THolidaysDate");
//                        return new ArrayList<>();
//                    }
//                } else {
//                    log.warn("Redis中数据不是List类型");
//                    return new ArrayList<>();
//                }
//            } catch (Exception e) {
//                log.error("从Redis获取节假日数据失败", e);
//                // 异常情况下返回空列表或从数据库获取
//                return new ArrayList<>();
//            }
//        }
//
//
//}